package asynccall

import (
	"clientDemo/service/modulemgr"
	"clientDemo/utils"
	"fmt"
	"runtime"
	"sync"
	"time"
)

var (
	once            sync.Once
	mainGoroutineID uint64
)

func SetMainGoroutine(id uint64) {
	mainGoroutineID = id
}

type AsyncCallModule struct {
	workers map[string]chan Task
	wg      sync.WaitGroup
	mu      sync.Mutex // 保护 workers 的互斥锁
}

func NewTimerModule() *AsyncCallModule {
	tmp := &AsyncCallModule{
		workers: make(map[string]chan Task),
	}
	for _, name := range []string{MainCall_Name} {
		tmp.workers[name] = make(chan Task, 10)
		tmp.wg.Add(1)
		go Worker(name, tmp.workers[name], &tmp.wg)
	}
	return tmp
}
func (m *AsyncCallModule) Init(mm modulemgr.IModuleManager) (bool, error) {

	return true, nil

}
func (m *AsyncCallModule) Run(mm modulemgr.IModuleManager) (bool, error) {
	return false, nil
}

// AsyncDelayTimer2 创建一个延迟定时器函数
func (m *AsyncCallModule) AsyncDelayTimer2(delayTime time.Duration, cb func()) {
	// 设置一个5秒后的定时器
	timer := time.After(delayTime)

	// 在新的goroutine中处理定时器
	go func() {
		<-timer // 等待定时器触发
		cb()
		// 这里可以放置需要定时执行的代码
	}()
}

func (m *AsyncCallModule) AddTask(workerName string, delay time.Duration, task Task) {
	m.mu.Lock() // 加锁以保护对 workers 的访问
	if m.workers[workerName] == nil {
		m.workers[workerName] = make(chan Task, 10)
		m.wg.Add(1)
		go Worker(workerName, m.workers[workerName], &m.wg)
	}
	m.mu.Unlock() // 解锁
	go func() {
		<-time.After(delay)
		m.mu.Lock() // 加锁以保护对 workers 的访问
		// 发送任务到工作协程
		m.workers[workerName] <- task
		m.mu.Unlock() // 解锁
	}()
}

// Close 关闭所有工作协程的通道
func (m *AsyncCallModule) Close() {
	m.mu.Lock()
	for _, ch := range m.workers {
		close(ch)
	}
	m.mu.Unlock()
	m.wg.Wait() // 等待所有工作协程完成
}

// AsyncDelayTimer 创建一个延迟定时器函数
func (m *AsyncCallModule) AsyncDelayTimer(delayTime time.Duration, cb func()) {
	m.AddTask(MainCall_Name, delayTime, cb)
	//tm := NewTaskManager([]string{"Worker1", "Worker2"})
	//tm.AddTask("Worker1", cb)
	/*	go func() {
		// 创建一个 channel 用于通知回调
		done := make(chan struct{})
		// 设置定时器
		timer := time.After(delayTime)

		// 启动一个 goroutine 等待定时器
		go func() {
			<-timer            // 等待定时器触发
			done <- struct{}{} // 发送信号
		}()

		// 在原协程中等待信号并执行回调
		select {
		case <-done:
			cb() // 在当前协程中执行回调
		}

	}()*/
}

// Worker 定义了一个工作协程
func Worker(name string, tasks <-chan Task, wg *sync.WaitGroup) {
	defer wg.Done()
	runtime.LockOSThread()
	defer runtime.UnlockOSThread()
	if name == MainCall_Name {
		once.Do(func() {
			SetMainGoroutine(uint64(utils.GetGoroutineID()))
		})
	}
	for task := range tasks {
		fmt.Printf("%s: Starting task\n", name)
		task()
		fmt.Printf("%s: Task completed\n", name)
	}
}

//
//// TaskManager 管理任务和工作协程
//type TaskManager struct {
//	workers map[string]chan Task
//	wg      sync.WaitGroup
//}
//
//// NewTaskManager 创建一个新的任务管理器
//func NewTaskManager(workerNames []string) *TaskManager {
//	tm := &TaskManager{
//		workers: make(map[string]chan Task),
//	}
//	for _, name := range workerNames {
//		tm.workers[name] = make(chan Task, 10)
//		tm.wg.Add(1)
//		go Worker(name, tm.workers[name], &tm.wg)
//	}
//	return tm
//}
//
//// AddTask 为指定名称的协程添加任务
//func (tm *TaskManager) AddTask(workerName string, task Task) {
//	if ch, ok := tm.workers[workerName]; ok {
//		ch <- task
//	} else {
//		fmt.Printf("Worker %s not found\n", workerName)
//	}
//}
//
//// Close 关闭所有工作协程的通道
//func (tm *TaskManager) Close() {
//	for _, ch := range tm.workers {
//		close(ch)
//	}
//	tm.wg.Wait()
//}
